home *** CD-ROM | disk | FTP | other *** search
/ PC go! 2008 April / PCgo 2008-04 (DVD).iso / interface / contents / demoversionen_3846 / 13664 / files / Data1.cab / propdialog.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-10-16  |  15.4 KB  |  639 lines
  1. /******************************************************************/
  2. /*                                                                */
  3. /*                      TurboCAD for Windows                      */
  4. /*                   Copyright (c) 1993 - 2001                    */
  5. /*             International Microcomputer Software, Inc.         */
  6. /*                            (IMSI)                              */
  7. /*                      All rights reserved.                      */
  8. /*                                                                */
  9. /******************************************************************/
  10.  
  11. // PropDialog.cpp : implementation file
  12. //
  13.  
  14. #include "stdafx.h"
  15. #include "LTSample.h"
  16. #include "PropDialog.h"
  17. #include "PropModify.h"
  18. #include "AddProperty.h"
  19.  
  20. #ifdef _DEBUG
  21. #define new DEBUG_NEW
  22. #undef THIS_FILE
  23. static char THIS_FILE[] = __FILE__;
  24. #endif
  25.  
  26. CString VariantToText(VARIANT *pvarVal, UINT IDS_ARRAY)
  27. {
  28.     CString cstrText;
  29.     if (pvarVal != NULL)
  30.     {
  31.         
  32.         switch (pvarVal->vt)
  33.         {
  34.             case VT_EMPTY:
  35.                 cstrText = "Empty";
  36.             break;
  37.             case VT_I2:
  38.                 cstrText.Format("%#X", pvarVal->iVal);
  39.             break;
  40.             case VT_I4:
  41.                 cstrText.Format("%#X", pvarVal->lVal);
  42.             break;
  43.             case VT_R4:
  44.                 cstrText.Format("%f", pvarVal->fltVal);
  45.             break;
  46.             case VT_R8:
  47.                 cstrText.Format("%f", pvarVal->dblVal);
  48.             break;    
  49.             case VT_CY:
  50.             {
  51.                 COleCurrency currency((const VARIANT&)pvarVal);
  52.                 cstrText = currency.Format();
  53.             }
  54.             break;
  55.             case VT_DATE:
  56.             {
  57.                 COleDateTime time((const VARIANT&)pvarVal);
  58.                 cstrText = time.Format();
  59.             }
  60.             break;
  61.             case VT_BSTR:
  62.                 cstrText = pvarVal->bstrVal;
  63.             break;
  64.             case VT_BOOL:
  65.                 cstrText = pvarVal->bVal ? "TRUE" : "FALSE";
  66.             break;
  67.             case VT_ARRAY | VT_I2:
  68.             case VT_ARRAY | VT_I4:
  69.             case VT_ARRAY | VT_R4:
  70.             case VT_ARRAY | VT_R8:
  71.             case VT_ARRAY | VT_CY:
  72.             case VT_ARRAY | VT_DATE:
  73.             case VT_ARRAY | VT_BSTR:
  74.             case VT_ARRAY | VT_BOOL:
  75.                 cstrText.LoadString(IDS_ARRAY);
  76.             break;
  77.             default:
  78.                 cstrText = "Unknown type";
  79.         }
  80.     }
  81.     return cstrText;
  82. }
  83.  
  84. void TextToVariant(CString& cstrText, VARIANT *pvarVal, VARTYPE vt)
  85. {
  86.     if (pvarVal != NULL)
  87.     {
  88.         ::VariantInit(pvarVal);
  89.         switch (vt)
  90.         {
  91.             case VT_I2:
  92.                 pvarVal->vt = vt;
  93.                 pvarVal->iVal = atoi(cstrText);
  94.             break;
  95.             case VT_I4:
  96.                 pvarVal->vt = vt;
  97.                 pvarVal->lVal = atol(cstrText);
  98.             break;
  99.             case VT_R4:
  100.                 pvarVal->vt = vt;
  101.                 pvarVal->fltVal = (float)atof(cstrText);
  102.             break;
  103.             case VT_R8:
  104.                 pvarVal->vt = vt;
  105.                 pvarVal->dblVal = atof(cstrText);
  106.             break;    
  107.             case VT_CY:
  108.             {
  109.                 COleCurrency currency;
  110.                 if (currency.ParseCurrency(cstrText))
  111.                 {
  112.                     pvarVal->vt = vt;
  113.                     pvarVal->cyVal = currency;
  114.                 }
  115.             }
  116.             break;
  117.             case VT_DATE:
  118.             {
  119.                 COleDateTime time;
  120.                 if (time.ParseDateTime(cstrText))
  121.                 {
  122.                     pvarVal->vt = vt;
  123.                     pvarVal->date = time;
  124.                 }
  125.             }
  126.             break;
  127.             case VT_BSTR:
  128.                 pvarVal->vt = vt;
  129.                 pvarVal->bstrVal = cstrText.AllocSysString();
  130.             break;
  131.             case VT_BOOL:
  132.                 if (cstrText.CompareNoCase("True"))
  133.                 {
  134.                     pvarVal->vt = vt;
  135.                     pvarVal->bVal = TRUE;
  136.                 }
  137.                 else if (cstrText.CompareNoCase("False"))
  138.                 {
  139.                     pvarVal->vt = vt;
  140.                     pvarVal->bVal = FALSE;
  141.                 }
  142.             break;
  143.         }
  144.     }
  145. }
  146.  
  147. CString VartypeToText(SHORT vt)
  148. {
  149.     CString cstrText;
  150.     SHORT vtL = vt & 0x0FFF;
  151.     SHORT vtH = vt & 0xF000;
  152.  
  153.     switch (vtH)
  154.     {
  155.         case VT_RESERVED:
  156.             cstrText = "VT_RESERVED";
  157.         break;
  158.         case VT_BYREF:
  159.             cstrText = "VT_BYREF";
  160.         break;
  161.         case VT_ARRAY:
  162.             cstrText = "VT_ARRAY";
  163.         break;
  164.     }
  165.  
  166.     if (!cstrText.IsEmpty())
  167.         cstrText += " | ";
  168.  
  169.     switch (vtL)
  170.     {
  171.         case VT_EMPTY:
  172.             cstrText += "VT_EMPTY";
  173.         break;
  174.         case VT_NULL:
  175.             cstrText += "VT_NULL";
  176.         break;
  177.         case VT_I2:
  178.             cstrText += "VT_I2";
  179.         break;
  180.         case VT_I4:
  181.             cstrText += "VT_I4";
  182.         break;
  183.         case VT_R4:
  184.             cstrText += "VT_R4";
  185.         break;
  186.         case VT_R8:
  187.             cstrText += "VT_R8";
  188.         break;
  189.         case VT_CY:
  190.             cstrText += "VT_CY";
  191.         break;
  192.         case VT_DATE:
  193.             cstrText += "VT_DATE";
  194.         break;
  195.         case VT_BSTR:
  196.             cstrText += "VT_BSTR";
  197.         break;
  198.         case VT_DISPATCH:
  199.             cstrText += "VT_DISPATCH";
  200.         break;
  201.         case VT_ERROR:
  202.             cstrText += "VT_ERROR";
  203.         break;
  204.         case VT_BOOL:
  205.             cstrText += "VT_BOOL";
  206.         break;
  207.         case VT_VARIANT:
  208.             cstrText += "VT_VARIANT";
  209.         break;
  210.         case VT_UNKNOWN:
  211.             cstrText += "VT_UNKNOWN";
  212.         break;
  213.         case VT_UI1:
  214.             cstrText += "VT_UI1";
  215.         break;
  216.     }
  217.     return cstrText;
  218. }
  219.  
  220. VARTYPE TextToVartype(CString& cstrText)
  221. {
  222.     VARTYPE vt = VT_EMPTY;
  223.  
  224.     if (cstrText.Find("VT_RESERVED") >= 0)
  225.         vt |= VT_RESERVED;
  226.  
  227.     if (cstrText.Find("VT_BYREF") >= 0)
  228.         vt |= VT_BYREF;
  229.             
  230.     if (cstrText.Find("VT_ARRAY") >= 0)
  231.         vt |= VT_ARRAY;
  232.  
  233.     if (cstrText.Find("VT_EMPTY") >= 0)
  234.         vt |= VT_EMPTY;
  235.  
  236.     if (cstrText.Find("VT_NULL") >= 0)
  237.         vt |= VT_NULL;
  238.  
  239.     if (cstrText.Find("VT_I2") >= 0)
  240.         vt |= VT_I2;
  241.  
  242.     if (cstrText.Find("VT_I4") >= 0)
  243.         vt |= VT_I4;
  244.  
  245.     if (cstrText.Find("VT_R4") >= 0)
  246.         vt |= VT_R4;
  247.  
  248.     if (cstrText.Find("VT_R8") >= 0)
  249.         vt |= VT_R8;
  250.  
  251.     if (cstrText.Find("VT_CY") >= 0)
  252.         vt |= VT_CY;
  253.  
  254.     if (cstrText.Find("VT_DATE") >= 0)
  255.         vt |= VT_DATE;
  256.  
  257.     if (cstrText.Find("VT_BSTR") >= 0)
  258.         vt |= VT_BSTR;
  259.  
  260.     if (cstrText.Find("VT_DISPATCH") >= 0)
  261.         vt |= VT_DISPATCH;
  262.  
  263.     if (cstrText.Find("VT_ERROR") >= 0)
  264.         vt |= VT_ERROR;
  265.  
  266.     if (cstrText.Find("VT_BOOL") >= 0)
  267.         vt |= VT_BOOL;
  268.  
  269.     if (cstrText.Find("VT_VARIANT") >= 0)
  270.         vt |= VT_VARIANT;
  271.  
  272.     if (cstrText.Find("VT_UNKNOWN") >= 0)
  273.         vt |= VT_UNKNOWN;
  274.  
  275.     if (cstrText.Find("VT_UI1") >= 0)
  276.         vt |= VT_UI1;
  277.  
  278.     return vt;
  279. }
  280.  
  281. /////////////////////////////////////////////////////////////////////////////
  282. // CPropDialog dialog
  283.  
  284.  
  285. CPropDialog::CPropDialog(Properties *pProps, CWnd* pParent /*=NULL*/)
  286.     : CDialog(CPropDialog::IDD, pParent)
  287. {
  288.     //{{AFX_DATA_INIT(CPropDialog)
  289.         // NOTE: the ClassWizard will add member initialization here
  290.     //}}AFX_DATA_INIT
  291.     m_pProps = pProps;
  292. }
  293.  
  294.  
  295. void CPropDialog::DoDataExchange(CDataExchange* pDX)
  296. {
  297.     CDialog::DoDataExchange(pDX);
  298.     //{{AFX_DATA_MAP(CPropDialog)
  299.         // NOTE: the ClassWizard will add DDX and DDV calls here
  300.     //}}AFX_DATA_MAP
  301. }
  302.  
  303.  
  304. BEGIN_MESSAGE_MAP(CPropDialog, CDialog)
  305.     //{{AFX_MSG_MAP(CPropDialog)
  306.     ON_BN_CLICKED(IDC_MODIFY, OnModify)
  307.     ON_BN_CLICKED(IDC_NEW, OnAdd)
  308.     //}}AFX_MSG_MAP
  309. END_MESSAGE_MAP()
  310.  
  311. /////////////////////////////////////////////////////////////////////////////
  312. // CPropDialog message handlers
  313. #define W_COLUMN    20
  314.  
  315. #define IND_SUBITEMINDEX    0
  316. #define IND_SUBITEMID        1
  317. #define IND_SUBITEMNAME        2
  318. #define IND_SUBITEMREADONLY    3
  319. #define IND_SUBITEMTYPE        4
  320. #define IND_SUBITEMVALUE    5
  321.  
  322. #define IND_COLUMNINDEX        0
  323. #define IND_COLUMNID        1
  324. #define IND_COLUMNAME        2
  325. #define IND_COLUMNREADONLY    3
  326. #define IND_COLUMNTYPE        4
  327. #define IND_COLUMNVALUE        5
  328.  
  329.  
  330. BOOL CPropDialog::OnInitDialog() 
  331. {
  332.     CDialog::OnInitDialog();
  333.  
  334.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  335.     
  336.     if (pPropsList != NULL)
  337.     {
  338.         LV_COLUMN lvcolumn;
  339.         lvcolumn.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH;
  340.         lvcolumn.fmt = LVCFMT_LEFT;
  341.  
  342.         CString sResString;
  343.         sResString.LoadString(IDS_PROPERTY_INDEX);
  344.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  345.  
  346.         lvcolumn.iSubItem = IND_SUBITEMINDEX;
  347.         lvcolumn.cx = W_COLUMN * 4;
  348.         pPropsList->InsertColumn(IND_COLUMNINDEX, &lvcolumn);  // assumes return value is OK.
  349.  
  350.         sResString.LoadString(IDS_PROPERTY_ID);
  351.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  352.         lvcolumn.iSubItem = IND_SUBITEMID;
  353.         lvcolumn.cx = W_COLUMN * 3;
  354.         pPropsList->InsertColumn(IND_COLUMNID, &lvcolumn);  // assumes return value is OK.
  355.  
  356.         sResString.LoadString(IDS_PROPERTY_NAME);
  357.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  358.         lvcolumn.cx = W_COLUMN * 5;
  359.         lvcolumn.iSubItem = IND_SUBITEMNAME;
  360.         pPropsList->InsertColumn(IND_COLUMNAME, &lvcolumn);  // assumes return value is OK.
  361.  
  362.         sResString.LoadString(IDS_PROPERTY_READONLY);
  363.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  364.         lvcolumn.cx = W_COLUMN * 4;
  365.         lvcolumn.iSubItem = IND_SUBITEMREADONLY;
  366.         pPropsList->InsertColumn(IND_COLUMNREADONLY, &lvcolumn);  // assumes return value is OK.
  367.  
  368.         sResString.LoadString(IDS_PROPERTY_TYPE);
  369.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  370.         lvcolumn.cx = W_COLUMN * 4;
  371.         lvcolumn.iSubItem = IND_SUBITEMTYPE;
  372.         pPropsList->InsertColumn(IND_COLUMNTYPE, &lvcolumn);  // assumes return value is OK.
  373.  
  374.         sResString.LoadString(IDS_PROPERTY_VALUE);
  375.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  376.         lvcolumn.cx = W_COLUMN * 4;
  377.         lvcolumn.iSubItem = IND_SUBITEMVALUE;
  378.         pPropsList->InsertColumn(IND_COLUMNVALUE, &lvcolumn);  // assumes return value is OK.
  379.     }
  380.  
  381.  
  382.     if (m_pProps != NULL)
  383.     {
  384.  
  385.         long lCount = 0;
  386.         HRESULT hRes = m_pProps->get_Count(&lCount);
  387.         if (SUCCEEDED(hRes))
  388.         {
  389.  
  390.             Property *pProp = NULL;
  391.             CString cstrText;
  392.             BSTR bstrVal = NULL;
  393.             long lVal = 0;
  394.             long lID = 0;
  395.             BOOL bVal = FALSE;
  396.             COleVariant *pvarVal;
  397.             SHORT iVal = 0;
  398.  
  399.  
  400.             VARIANT varIndex;
  401.             ::VariantInit(&varIndex);
  402.             varIndex.vt = VT_I4;
  403.  
  404.             LV_ITEM            lvitem;
  405.             int                index = 0;
  406.  
  407.             for (long iItem = 0; iItem < lCount; iItem++)
  408.             {
  409.  
  410.                 varIndex.lVal = iItem;
  411.                 hRes = m_pProps->get_Item(&varIndex, &pProp);
  412.                 if (SUCCEEDED(hRes))
  413.                 {
  414.                     ASSERT(pProp != NULL);
  415.  
  416.                     lvitem.mask = LVIF_TEXT;
  417.                     lvitem.iItem = index;
  418.  
  419.                     hRes = pProp->get_ID(&lID);
  420.                     if (SUCCEEDED(hRes))
  421.                     {
  422.                         lvitem.iSubItem = IND_SUBITEMINDEX;
  423.                         hRes = pProp->get_Index(&lVal);
  424.                         if (SUCCEEDED(hRes))
  425.                             cstrText.Format("%d", lVal);
  426.                         else
  427.                             cstrText = "?";
  428.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  429.                         index = pPropsList->InsertItem(&lvitem);
  430.                         ASSERT(index >= 0);
  431.  
  432.                         lvitem.iSubItem = IND_SUBITEMID;
  433.                         cstrText.Format("%d", lID);
  434.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  435.                         VERIFY(pPropsList->SetItem(&lvitem));
  436.  
  437.                         hRes = pProp->get_Name(&bstrVal);
  438.                         ASSERT(SUCCEEDED(hRes));
  439.                         lvitem.iSubItem = IND_SUBITEMNAME;
  440.                         cstrText = bstrVal;
  441.                         ::SysFreeString(bstrVal);
  442.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  443.                         VERIFY(pPropsList->SetItem(&lvitem));
  444.  
  445.                         hRes = pProp->get_ReadOnly(&iVal);
  446.                         lvitem.iSubItem = IND_SUBITEMREADONLY;
  447.                         lvitem.pszText = bVal ? "r-" : "rw";
  448.                         VERIFY(pPropsList->SetItem(&lvitem));
  449.  
  450.                         hRes = pProp->get_Type(&iVal);
  451.                         lvitem.iSubItem = IND_SUBITEMTYPE;
  452.                         cstrText = VartypeToText(iVal);
  453.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  454.                         VERIFY(pPropsList->SetItem(&lvitem));
  455.  
  456.                         pvarVal = new COleVariant();
  457.                         hRes = pProp->get_Value(0, pvarVal);
  458.                         lvitem.iSubItem = IND_SUBITEMVALUE;
  459.                         cstrText = VariantToText(pvarVal, IDS_SOURCE);
  460.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  461.                         VERIFY(pPropsList->SetItem(&lvitem));
  462.  
  463.                         VERIFY(index == m_arrVal.Add(pvarVal));
  464.                         VERIFY(pPropsList->SetItemData(index, (DWORD)pProp));
  465.                         index++;
  466.                     }
  467.                     else
  468.                         pProp->Release();
  469.                 }
  470.             }
  471.         }
  472.     }
  473.  
  474.     return TRUE;  // return TRUE unless you set the focus to a control
  475.                   // EXCEPTION: OCX Property Pages should return FALSE
  476. }
  477.  
  478. void CPropDialog::OnModify() 
  479. {
  480.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  481.     if (pPropsList != NULL)
  482.     {
  483.         int iSelItem = pPropsList->GetNextItem(-1, LVNI_SELECTED);        
  484.         if (iSelItem >= 0)
  485.         {
  486.             COleVariant *pvarVal = (COleVariant *)m_arrVal.GetAt(iSelItem);
  487.             if (pvarVal != NULL)
  488.             {
  489.                 CString cstrName = pPropsList->GetItemText(iSelItem, IND_SUBITEMNAME);
  490.                 CString cstrType = pPropsList->GetItemText(iSelItem, IND_SUBITEMTYPE);
  491.  
  492.                 CPropModify dlgModify(pvarVal, cstrName, cstrType, this);
  493.                 if (dlgModify.DoModal() == IDOK)
  494.                 {
  495.                     CString cstrText = VariantToText(&(dlgModify.m_varVal), IDS_MODIFIED);
  496.                     VERIFY(SUCCEEDED(::VariantCopyInd(pvarVal, dlgModify.m_varVal)));
  497.                     LV_ITEM            lvitem;
  498.                     lvitem.mask = LVIF_TEXT;
  499.                     lvitem.iItem = iSelItem;
  500.                     lvitem.iSubItem = IND_SUBITEMVALUE;
  501.                     lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  502.  
  503.                     VERIFY(pPropsList->SetItem(&lvitem));
  504.                     pPropsList->Update(iSelItem);
  505.                 }
  506.             }
  507.         }
  508.     
  509.     }
  510. }
  511.  
  512. void CPropDialog::OnCancel() 
  513. {
  514.     // TODO: Add extra cleanup here
  515.     
  516.     CDialog::OnCancel();
  517. }
  518.  
  519. void CPropDialog::OnOK() 
  520. {
  521.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  522.     if (pPropsList != NULL)
  523.     {
  524.         ASSERT(::IsWindow(pPropsList->GetSafeHwnd()));
  525.         Property *pProp = NULL;
  526.         int iCount = pPropsList->GetItemCount();
  527.         for (int iItem = 0; iItem < iCount; iItem++)
  528.         {
  529.             COleVariant *pvar = (COleVariant *)m_arrVal.GetAt(iItem);
  530.             pProp = (Property *)pPropsList->GetItemData(iItem);
  531.             if (pProp == NULL)
  532.             {
  533.                 CString cstrName = pPropsList->GetItemText(iItem, IND_SUBITEMNAME);
  534.                 BSTR bstrName = cstrName.AllocSysString();
  535.  
  536.                 COleVariant varReadOnly;
  537.                 CString cstrReadOnly = pPropsList->GetItemText(iItem, IND_SUBITEMREADONLY);
  538.                 TextToVariant(cstrReadOnly, &varReadOnly, VT_BOOL);
  539.  
  540.                 COleVariant varMissing;
  541.                 varMissing.vt = VT_ERROR;
  542.                 varMissing.scode = DISP_E_PARAMNOTFOUND;
  543.  
  544.                 HRESULT hRes = m_pProps->Add(bstrName,
  545.                                              pvar,
  546.                                              varReadOnly,
  547.                                              &varMissing,
  548.                                              &pProp);
  549.                 ::SysFreeString(bstrName);
  550.                 if (SUCCEEDED(hRes))
  551.                     pProp->Release();
  552.                 else
  553.                 {
  554.                     CString cstrError;
  555.                     cstrError.Format(IDS_CANNOTADDPROPERTY, cstrName);                    
  556.                     AfxMessageBox(cstrError);
  557.                 }
  558.             }
  559.             else
  560.                 pProp->put_Value(0,pvar);
  561.         }
  562.     }
  563.     else
  564.         ASSERT(FALSE);
  565.     CDialog::OnOK();
  566. }
  567.  
  568. BOOL CPropDialog::DestroyWindow() 
  569. {
  570.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  571.     if (pPropsList != NULL)
  572.     {
  573.         ASSERT(::IsWindow(pPropsList->GetSafeHwnd()));
  574.         Property *pProp = NULL;
  575.         COleVariant *pvarVal;
  576.         int iCount = pPropsList->GetItemCount();
  577.         for (int iItem = 0; iItem < iCount; iItem++)
  578.         {
  579.             pProp = (Property *)pPropsList->GetItemData(iItem);
  580.             if (pProp != NULL)
  581.                 pProp->Release();
  582.             pvarVal = (COleVariant *)m_arrVal.GetAt(iItem);
  583.             if (pvarVal != NULL)
  584.                 delete pvarVal;
  585.         }
  586.     }
  587.     else
  588.         ASSERT(FALSE);
  589.     
  590.     return CDialog::DestroyWindow();
  591. }
  592.  
  593. void CPropDialog::OnAdd() 
  594. {
  595.     CAddProperty dlgAdd;
  596.     if (dlgAdd.DoModal())
  597.     {
  598.         CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  599.  
  600.         int iCount = pPropsList->GetItemCount();
  601.         LV_ITEM            lvitem;
  602.         lvitem.mask = LVIF_TEXT;
  603.         lvitem.iItem = iCount;
  604.  
  605.         lvitem.iSubItem = IND_SUBITEMINDEX;
  606.         CString cstrText = "?";
  607.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  608.         int index = pPropsList->InsertItem(&lvitem);
  609.         ASSERT(index >= 0);
  610.  
  611.         lvitem.iSubItem = IND_SUBITEMID;
  612.         cstrText = "?";
  613.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  614.         VERIFY(pPropsList->SetItem(&lvitem));
  615.  
  616.         lvitem.iSubItem = IND_SUBITEMNAME;
  617.         cstrText = dlgAdd.m_cstrName;
  618.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  619.         VERIFY(pPropsList->SetItem(&lvitem));
  620.  
  621.         lvitem.iSubItem = IND_SUBITEMREADONLY;
  622.         lvitem.pszText = dlgAdd.m_bReadOnly ? "r-" : "rw";
  623.         VERIFY(pPropsList->SetItem(&lvitem));
  624.  
  625.         lvitem.iSubItem = IND_SUBITEMTYPE;
  626.         cstrText = dlgAdd.m_cstrType;
  627.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  628.         VERIFY(pPropsList->SetItem(&lvitem));
  629.  
  630.         COleVariant *pvarVal = new COleVariant();
  631.         pvarVal->vt = TextToVartype(cstrText);
  632.         lvitem.iSubItem = IND_SUBITEMVALUE;
  633.         cstrText = VariantToText(pvarVal, IDS_SOURCE);
  634.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  635.         VERIFY(pPropsList->SetItem(&lvitem));
  636.         VERIFY(index == m_arrVal.Add(pvarVal));
  637.     }
  638. }
  639.